(()=>{
    // 1. 找最长单词 ["aaaaaaaa","bbbb","ccc"]
    // 2. 菲波纳锲 第三项的值 等于前两项值的和
    // 3. 冒泡排序

    // const fn = (arr:string[]):string => {
    //     let newArr :Array<string>=[]
    //     newArr = arr.sort((a,b)=>{
    //         return b.length - a.length
    //     })
    //     return newArr[0]
    // }
    // console.log(fn(["aaaaaaaa","bbbb","ccc"]));

    //菲波纳锲 1 1 2 3 5 8 13 21 34 55 89 144
    // const fn = (n:number):number[] => {
    //     let arr:number[] = [1,1]
    //     if(n<=2){
    //         return arr
    //     }else{
    //        for (let i = 2; i < n; i++) {
    //             arr[i] = arr[i-1]+ arr[i-2]
    //        }
    //     }
    //     return arr
    // }
    // console.log(fn(100));
    


    // const fn = (arr:number[]):number[] =>{
     
    //     if (arr.length<=1) {
    //         return arr
    //     }else{
    //         for (let i = 0; i < arr.length; i++) {
    //             for (let j = i+1; j < arr.length; j++) {
    //                 if (arr[j]<arr[i]) { //2 1  
    //                     let temp = arr[j]
    //                     arr[j] = arr[i]
    //                     arr[i] = temp
    //                 }
                  
    //             }
    //        }
    //     }
    //     return arr
    // }
    // console.log(fn([1,2,3,88,90,50]));
    
    /*
        泛型 

        泛型是指 在定义函数/接口/类型时 不提前设置类型 而是在使用的时候 在函数中指定类型
        1. 在函数中使用泛型
        2. 在接口中使用泛型
        3. 在类中使用泛型

        泛型约束
        接口泛型约束

        // 
    */

    // function fn <T,Y>(arg:T,age:Y):string{
    //     // console.log(arg);
    //     return `arg:${arg},age:${age}`
    // }
    // console.log(fn<string,number>("姜国庆",18));
    // console.log(fn<number>(2));
    // console.log(fn<boolean>(false));
    
    // interface Obj {
    //     <T,Y>(name:T,age:Y):string
    // }
    
    // let fn:Obj = function<T,Y>(name:T,age:Y){
    //     let str : string = ""
    //     str = `name:${name},age:${age}`
    //     return str
    // }
    
    // console.log(fn<string,number>("王昆鹏",18));
    
    // class Person <T> {
    //     name:T
    //     constructor(name:T){
    //         this.name = name
    //     }
    //     get_name (){
    //         return this.name
    //     }
    // }
    // let person = new Person<string>("胡永泽")
    // console.log(person.get_name());

    // interface Person{
    //     name:string,
    //     age:number
    // }

    // function student<T extends Person> (obj:T):T {
    //     return obj
    // }

    // console.log(student({name:"张三",age:19}));

    /*
        类型别名
        1. 继承 通过&
    */

    // type A ={
    //     name:string,
      
    // }

    

    // type B = A &{
    //     age:number
    // }
    /*
        接口
        1. 继承
        2. 接口定义可以重名 每次声明相当于追加到对应的接口上
        3. readonly 只读
        4. 可选属性 ？
    */ 
    interface A {
        readonly name:string
    }

    interface B extends A{
        age:number
    }

    interface A {
        like?:boolean
    }

    let obj :B = {
        name:"张三",
        age:10,
        like:false
    }
    console.log(obj);

    // let aaa  = ""
    
})()